home *** CD-ROM | disk | FTP | other *** search
/ Netware Super Library / Netware Super Library.iso / user_etc / userinfo / obs.h next >
Encoding:
C/C++ Source or Header  |  1992-06-11  |  6.5 KB  |  332 lines
  1. // These functions have been tested with Novell Netware 3.11
  2. //
  3. // Written by: Douglas R. Cannon
  4. // On: 4/9/1992
  5. // email:      dougc@bert.cs.byu.edu
  6. //
  7.  
  8. #include <stdio.h>
  9. #include <dos.h>
  10. #include <string.h>
  11. #include <process.h>
  12. #include <ctype.h>
  13.  
  14.  
  15. #define DOS 0x21
  16.  
  17. REGPACK R;
  18.  
  19. typedef unsigned char byte;
  20. typedef unsigned int  word;
  21.  
  22. typedef struct {
  23.   byte high_byte;
  24.   byte low_byte;
  25. } nw_int;
  26.  
  27. typedef struct {
  28.   byte highest_byte;
  29.   byte higher_byte;
  30.   byte lower_byte;
  31.   byte lowest_byte;
  32. } nw_long;
  33.  
  34. struct address {
  35.   byte network_number[4];
  36.   byte node_address[6];
  37.   byte socket_number[2];
  38. };
  39.  
  40. struct object_name {
  41.   word len;
  42.   nw_long object_id;
  43.   nw_int object_type;
  44.   char object_name[48];
  45. };
  46.  
  47. struct object_info {
  48.   word len;
  49.   nw_long object_id;
  50.   nw_int object_type;
  51.   char object_name[48];
  52.   char login_time[7];
  53. };
  54.  
  55. struct has_props {
  56.   word len;
  57.   nw_long object_id;
  58.   nw_int object_type;
  59.   char object_name[48];
  60.   byte object_flag;
  61.   byte object_security;
  62.   byte object_has_properties;
  63. };
  64.  
  65. struct property {
  66.   word len;
  67.   char property_name[16];
  68.   byte property_flags;
  69.   byte property_security;
  70.   nw_long sequence_number;
  71.   byte property_has_value;
  72.   byte more_properties;
  73. };
  74.  
  75. struct connections {
  76.   word len;
  77.   byte number_of_connections;
  78.   byte connection_numbers[100];
  79. };
  80.  
  81.  
  82.  
  83. void print_set(byte buf[128]);
  84. void print_segment(byte buf[128]);
  85. int nw_long_equal(nw_long,nw_long);
  86.  
  87.  
  88.  
  89.  
  90. int get_connection_numbers(nw_int type,char *name,connections *buf)
  91. {
  92.   struct {
  93.     word len;
  94.     byte type;
  95.     nw_int object_type;
  96.     byte object_name_length;
  97.     char object_name[48];
  98.   } request_buffer;
  99.  
  100.   connections *reply_buffer = buf;
  101.  
  102.   request_buffer.len = sizeof(request_buffer)-2;
  103.   request_buffer.type = 0x15;
  104.   request_buffer.object_type = type;
  105.   request_buffer.object_name_length = 48;
  106.   strcpy(request_buffer.object_name,name);
  107.  
  108.   reply_buffer->len = sizeof(connections)-2;
  109.  
  110.   R.r_ax = 0xE300;
  111.   R.r_ds = FP_SEG(&request_buffer);
  112.   R.r_si = FP_OFF(&request_buffer);
  113.   R.r_es = FP_SEG(reply_buffer);
  114.   R.r_di = FP_OFF(reply_buffer);
  115.   intr(DOS,&R);
  116.  
  117.   return (_AL);
  118.  
  119. }
  120.  
  121.  
  122.  
  123. int get_internet_address(int con,address *buf)
  124. {
  125.   int x;
  126.  
  127.   struct {
  128.     word buffer_length;
  129.     byte type;
  130.     byte connection_number;
  131.   } request_buffer;
  132.  
  133.   struct {
  134.     word buffer_length;
  135.     byte network_number[4];
  136.     byte node_address[6];
  137.     byte socket_number[2];
  138.   } reply_buffer;
  139.  
  140.   request_buffer.buffer_length = sizeof(request_buffer)-2;
  141.   request_buffer.type = 0x13;
  142.   request_buffer.connection_number = con;
  143.   reply_buffer.buffer_length = sizeof(reply_buffer)-2;
  144.  
  145.   R.r_ax = 0xE300;
  146.   R.r_ds = FP_SEG(&request_buffer);
  147.   R.r_si = FP_OFF(&request_buffer);
  148.   R.r_es = FP_SEG(&reply_buffer);
  149.   R.r_di = FP_OFF(&reply_buffer);
  150.   intr(DOS,&R);
  151.  
  152.   if (_AL) return(_AL);
  153.  
  154.   for (x=0; x<4; x++)
  155.     buf->network_number[x] = reply_buffer.network_number[x];
  156.   for (x=0; x<6; x++)
  157.     buf->node_address[x] = reply_buffer.node_address[x];
  158.   for (x=0; x<2; x++)
  159.     buf->socket_number[x] = reply_buffer.socket_number[x];
  160.  
  161.   return 0;
  162.  
  163. }
  164.  
  165.  
  166.  
  167.  
  168.  
  169. int get_connection_information(int con,object_info *buf)
  170. {
  171.  
  172.   struct {
  173.     word len;
  174.     byte type;
  175.     byte connection_number;
  176.   } request_buffer;
  177.  
  178.   object_info *reply_buffer = buf;
  179.  
  180.   request_buffer.len = sizeof(request_buffer)-2;
  181.   request_buffer.type = 0x16;
  182.   request_buffer.connection_number = con;
  183.   reply_buffer->len = sizeof(object_info)-2;
  184.  
  185.   R.r_ax = 0xE300;
  186.   R.r_ds = FP_SEG(&request_buffer);
  187.   R.r_si = FP_OFF(&request_buffer);
  188.   R.r_es = FP_SEG(reply_buffer);
  189.   R.r_di = FP_OFF(reply_buffer);
  190.   intr(DOS,&R);
  191.  
  192.   return (_AL);
  193.  
  194. }
  195.  
  196.  
  197. int get_object_name(nw_long object_id,object_name *buf)
  198. {
  199.   struct {
  200.     word len;
  201.     byte type;
  202.     nw_long object_id;
  203.   } request_buffer;
  204.  
  205.   object_name *reply_buffer = buf;
  206.  
  207.   request_buffer.len = sizeof(request_buffer)-2;
  208.   request_buffer.type = 0x36;
  209.   request_buffer.object_id = object_id;
  210.   reply_buffer->len = sizeof(object_name)-2;
  211.  
  212.   R.r_ax = 0xE300;
  213.   R.r_ds = FP_SEG(&request_buffer);
  214.   R.r_si = FP_OFF(&request_buffer);
  215.   R.r_es = FP_SEG(reply_buffer);
  216.   R.r_di = FP_OFF(reply_buffer);
  217.   intr(DOS,&R);
  218.  
  219.   return (_AL);
  220.  
  221. }
  222.  
  223.  
  224.  
  225.  
  226.  
  227.  
  228. int scan_for_object(nw_long last_id,char *name,nw_int type,has_props *buf)
  229. {
  230.  
  231.   int x;
  232.  
  233.   struct {
  234.     word len;
  235.     byte type;
  236.     nw_long last_object_id;
  237.     nw_int object_type;
  238.     byte object_name_length;
  239.     byte object_name[48];
  240.   } request_buffer;
  241.  
  242.   has_props *reply_buffer = buf;
  243.  
  244.   request_buffer.len = sizeof(request_buffer)-2;
  245.   request_buffer.type = 0x37;
  246.   request_buffer.last_object_id = last_id;
  247.   request_buffer.object_type = type;
  248.   request_buffer.object_name_length = 48;
  249.   strcpy(request_buffer.object_name,name);
  250.   reply_buffer->len = sizeof(has_props)-2;
  251.  
  252.   R.r_ax = 0xE300;
  253.   R.r_ds = FP_SEG(&request_buffer);
  254.   R.r_si = FP_OFF(&request_buffer);
  255.   R.r_es = FP_SEG(reply_buffer);
  256.   R.r_di = FP_OFF(reply_buffer);
  257.   intr(DOS,&R);
  258.  
  259.   return(_AL);
  260.  
  261. }
  262.  
  263.  
  264.  
  265.  
  266.  
  267. int read_property_value(char *user,nw_int type,byte sn,char *prop,byte seg[128])
  268. {
  269.   int x,al;
  270.  
  271.   struct {
  272.     word len;
  273.     byte type;
  274.     nw_int object_type;
  275.     byte object_name_length;
  276.     char object_name[48];
  277.     byte segment_number;
  278.     byte property_name_length;
  279.     char property_name[16];
  280.   } request_buffer;
  281.  
  282.   struct {
  283.     word len;
  284.     byte property_value[128];
  285.     byte more_segments;
  286.     byte property_flags;
  287.   } reply_buffer;
  288.  
  289.   request_buffer.len = sizeof(request_buffer)-2;
  290.   request_buffer.type = 0x3D;
  291.   request_buffer.object_type = type;
  292.   request_buffer.object_name_length = 48;
  293.   strcpy(request_buffer.object_name,user);
  294.  
  295.   request_buffer.segment_number = sn;
  296.  
  297.   request_buffer.property_name_length = 16;
  298.   strcpy(request_buffer.property_name,prop);
  299.  
  300.   reply_buffer.len = sizeof(reply_buffer)-2;
  301.  
  302.   R.r_ax = 0xE300;
  303.   R.r_ds = FP_SEG(&request_buffer);
  304.   R.r_si = FP_OFF(&request_buffer);
  305.   R.r_es = FP_SEG(&reply_buffer);
  306.   R.r_di = FP_OFF(&reply_buffer);
  307.   intr(DOS,&R);
  308.   al = _AL;
  309.  
  310.   for (x=0; x<128; x++) seg[x]=reply_buffer.property_value[x];
  311.  
  312.   return(al);
  313.  
  314. }
  315.  
  316.  
  317.  
  318.  
  319.  
  320. int nw_long_equal(nw_long left,nw_long right)
  321. {
  322.   if (left.highest_byte != right.highest_byte) return 0;
  323.   if (left.higher_byte != right.higher_byte) return 0;
  324.   if (left.lower_byte != right.lower_byte) return 0;
  325.   if (left.lowest_byte != right.lowest_byte) return 0;
  326.  
  327.   return 1;
  328. }
  329.  
  330.  
  331.  
  332.